home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / info-service / www / src / midaswww-1.0 / custom.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-16  |  43.9 KB  |  1,503 lines
  1. #include <stdio.h>                              /* For printf and so on. */
  2. #include <string.h>
  3. #include <Mrm/MrmAppl.h>                        /* Motif Toolkit and MRM */
  4. #include <Xm/Text.h>
  5. #include <Xm/ToggleBG.h>
  6. #include <Xm/PushBG.h>
  7. #include <Xm/CascadeBG.h>
  8. #include <Xm/SeparatoG.h>
  9. #include <Xm/RowColumn.h>
  10. #include "midaslist.h"
  11. #include "midasoperand.h"
  12. #include "midasshell.h"
  13.  
  14. XmString MidasCharToString();
  15. MidasShell *MidasGetShell();
  16. Widget MidasFetch();
  17.  
  18. #ifndef VAX
  19. WidgetList DXmChildren();
  20. int DXmNumChildren();
  21. #endif
  22.  
  23. MidasOperand MidasGetAppResource();
  24.  
  25. struct VerbInMenu {
  26.     int     Verb;
  27.     int     Menu;
  28. };
  29.  
  30. typedef struct VerbInMenu VerbInMenu;
  31.  
  32. struct VerbStruct {
  33.     char *Command;
  34.     Boolean IsToggle;
  35. };
  36.     
  37. typedef struct VerbStruct VerbStruct; 
  38.  
  39. struct CustomHeader {
  40.     int    Modified;
  41.     int    Changed;
  42.     Widget Fetched;
  43.     Widget Parent;
  44.  
  45.     Widget CustomCommandText;
  46.     Widget CustomVerbAddButton;
  47.     Widget CustomVerbDeleteButton;
  48.     Widget CustomVerbList;
  49.     Widget CustomVerbText;
  50.     Widget CustomVerbIsToggle;
  51.     Widget CustomMenuAddButton;
  52.     Widget CustomMenuDeleteButton;
  53.     Widget CustomMenuList;
  54.     Widget CustomMenuText;
  55.     Widget CustomVMUpButton;
  56.     Widget CustomVMDownButton;
  57.     Widget CustomVMAddVerbButton;
  58.     Widget CustomVMAddMenuButton;
  59.     Widget CustomVMSeparatorButton;
  60.     Widget CustomVMRemoveButton;
  61.     Widget CustomVMList;
  62.     Widget CustomVMActiveLabel;
  63.     Widget CustomOKButton;
  64.     Widget CustomApplyButton;
  65.     Widget CustomCancelButton;
  66.     Widget CustomResetButton;
  67.     
  68.     List TempVerbList;
  69.     List TempMenuList;
  70.     List VerbList;
  71.     List MenuList;
  72.     List *VMList;
  73.     List ConnectList;
  74. };
  75.  
  76. typedef struct CustomHeader CustomHeader;
  77.  
  78. struct Link  {
  79.     Widget        Widget;
  80.     CustomHeader *Header;
  81. };
  82.  
  83. typedef struct Link Link;
  84.  
  85. static List CustomHeaders; 
  86. static int  ExitResponse; 
  87.  
  88. static void CustomSetActiveMenu(Header,Label)
  89.       CustomHeader *Header;
  90.       XmString Label;
  91. {
  92.     int n = 0;
  93.     Arg args[10];
  94.     XtSetArg(args[n],XmNlabelString,Label); n++;
  95.     XtSetValues(Header->CustomVMActiveLabel,args,n);
  96. }
  97. static char *CustomAppendArrow(name)
  98.     char *name;
  99. {
  100.     char *result;
  101.     result = strcpy(XtMalloc(strlen(name)+4),name);
  102.     return strcat(result," =>");
  103. }
  104. static Boolean CustomIsChild(Header,parent,child)
  105.       CustomHeader *Header;
  106.       List         *parent;
  107.       List         *child;
  108.  
  109. {
  110.     ListItem *i;
  111.  
  112.     for (i = parent->First; i != 0; i = i->Next)
  113.       {
  114.         VerbInMenu *vm = ((VerbInMenu *) i->Pointer);
  115.         if (vm->Menu != 0)
  116.           { 
  117.             ListItem *menu = MidasFindItemInListPos(&Header->TempMenuList,vm->Menu);
  118.             List *NewList = ((List *) menu->Pointer);
  119.             if (NewList = child) return 1;
  120.             else if (CustomIsChild(Header,NewList,child)) return 1;
  121.           }
  122.       }
  123.     return 0;
  124. }             
  125. static void CustomUpdatePositionsAdd(L,pos,verb)
  126.     List         *L;
  127.     int           pos;
  128.     int           verb;
  129. {
  130.     ListItem *i , *j;
  131.  
  132.     for (i = L->First; i != 0; i = i->Next)
  133.       {
  134.         List *menu = ((List *) i->Pointer); 
  135.         if (menu != 0)
  136.           for (j = menu->First; j != 0; j = j->Next)
  137.             {
  138.               VerbInMenu *vm = j->Pointer;
  139.               if (verb)
  140.                 {
  141.                   if (vm->Verb >= pos) vm->Verb += 1;
  142.                 }
  143.               else
  144.                 {
  145.                   if (vm->Menu >= pos) vm->Menu += 1;
  146.                 }
  147.             }
  148.         }
  149. };
  150. static void CustomUpdatePositionsRemove(L,pos,verb)
  151.     List         *L;
  152.     int           pos;
  153.     int           verb;
  154. {
  155.     ListItem *i, *j, *next;
  156.  
  157.     for (i = L->First; i != 0; i = i->Next)
  158.       {
  159.         List *menu = ((List *) i->Pointer); 
  160.         for (j = menu->First; j != 0; j = next)
  161.           {
  162.             VerbInMenu *vm = j->Pointer;
  163.             next = j->Next;
  164.             if (verb)
  165.               {
  166.                 if      (vm->Verb == pos) MidasRemoveItemFromList(menu,j);
  167.                 else if (vm->Verb >  pos) vm->Verb -= 1;
  168.               }
  169.             else
  170.               {
  171.                 if      (vm->Menu == pos) MidasRemoveItemFromList(menu,j);
  172.                 else if (vm->Menu >  pos) vm->Menu -= 1;
  173.               }
  174.           }
  175.       }
  176. };
  177. static void CustomUpdateSensitivity(Header) 
  178.                                       /*----Figures out which keys should be 
  179.                                             sensitive at the current time    */
  180.     CustomHeader *Header;
  181. {
  182.  
  183.     char *menu;
  184.     char *verb;
  185.     char *command;
  186.     Boolean sensitive;
  187.    
  188.     XtSetSensitive(Header->CustomApplyButton,Header->Changed != 0);
  189.     XtSetSensitive(Header->CustomResetButton,Header->Changed != 0);
  190.  
  191.     XtSetSensitive(Header->CustomVerbDeleteButton,
  192.                    Header->TempVerbList.Selected != 0);
  193.     XtSetSensitive(Header->CustomMenuDeleteButton,
  194.                    Header->TempMenuList.Selected != 0);
  195.  
  196.     verb    = XmTextGetString(Header->CustomVerbText);
  197.     command = XmTextGetString(Header->CustomCommandText);
  198.     sensitive = (strcmp(verb,"") != 0 && strcmp(command,"") != 0 );
  199.     XtSetSensitive(Header->CustomVerbAddButton,sensitive);
  200.     XtFree(command);
  201.     XtFree(verb);
  202.  
  203.     menu = XmTextGetString(Header->CustomMenuText);
  204.     sensitive = (strcmp(menu,"")!=0);
  205.     XtSetSensitive(Header->CustomMenuAddButton,sensitive);
  206.     XtFree(menu);
  207.  
  208.     if (Header->VMList == 0)
  209.       {
  210.         XtSetSensitive(Header->CustomVMAddMenuButton,0);
  211.         XtSetSensitive(Header->CustomVMAddVerbButton,0);
  212.         XtSetSensitive(Header->CustomVMSeparatorButton,0);
  213.         XtSetSensitive(Header->CustomVMRemoveButton,0);
  214.         XtSetSensitive(Header->CustomVMUpButton,0);
  215.         XtSetSensitive(Header->CustomVMDownButton,0);
  216.       }
  217.     else                
  218.       {
  219.         ListItem *item = Header->VMList->Selected;
  220.         XtSetSensitive(Header->CustomVMSeparatorButton,1);
  221.         XtSetSensitive(Header->CustomVMRemoveButton,(item!=0));
  222.         XtSetSensitive(Header->CustomVMUpButton,
  223.                        (item!=0 && item!=Header->VMList->First));
  224.         XtSetSensitive(Header->CustomVMDownButton,
  225.                        (item!=0 && item!=Header->VMList->Last));
  226.         sensitive = (Header->TempVerbList.Selected!=0);
  227.         if (sensitive)
  228.           sensitive=(MidasFindItemInList(Header->VMList,
  229.                      Header->TempVerbList.Selected->Entry)==0);
  230.         XtSetSensitive(Header->CustomVMAddVerbButton,sensitive);
  231.         sensitive = (Header->TempMenuList.Selected!=0);
  232.         if (sensitive)
  233.           {
  234.             char *entry = CustomAppendArrow(Header->TempMenuList.Selected->Entry);
  235.             sensitive=(MidasFindItemInList(Header->VMList,entry)==0);
  236.             XtFree(entry);
  237.           }
  238.         if (sensitive)
  239.           {
  240.             List *parent = ((List *) Header->TempMenuList.Selected->Pointer);
  241.             if (parent==0 || parent == Header->VMList) sensitive = 0;
  242.             else sensitive = (CustomIsChild(Header,parent,Header->VMList)==0);
  243.           }
  244.         XtSetSensitive(Header->CustomVMAddMenuButton,sensitive);
  245.       }
  246. }
  247. static CustomHeader *CustomFindHeader(w)
  248.       Widget w;
  249. {
  250.       Widget main;
  251.       CustomHeader *header;
  252.       int n = 0;
  253.       Arg args[10];
  254.       XtSetArg(args[n],XmNuserData , &header); n++;
  255.  
  256.       for (main=w;; main=XtParent(main)) 
  257.         {
  258.           XtGetValues(main,args,n);
  259.           if (header!=0 && header != (CustomHeader *) -1) return header;
  260.         }
  261. }
  262. static void CustomUpdateSensitivityCallback(w,closure,cbDataP)
  263.       Widget w; 
  264.       Opaque closure; 
  265.       XmAnyCallbackStruct *cbDataP;
  266. {
  267.     CustomHeader *Header = CustomFindHeader(w);
  268.     CustomUpdateSensitivity(Header);
  269. }
  270. static void CustomAddVerb(w,closure,cbDataP)
  271.       Widget w; 
  272.       Opaque closure; 
  273.       XmAnyCallbackStruct *cbDataP;
  274. {
  275.     int pos;
  276.     char *verb;
  277.     char *command;
  278.     ListItem *item;
  279.     CustomHeader *Header = CustomFindHeader(w);
  280.     Boolean istoggle;
  281.     VerbStruct *Verb;  
  282.  
  283.  
  284.     verb = XmTextGetString(Header->CustomVerbText);
  285.     command = XmTextGetString(Header->CustomCommandText);
  286.     istoggle = XmToggleButtonGetState(Header->CustomVerbIsToggle); 
  287.  
  288.     if (item = MidasFindItemInList(&Header->TempVerbList,verb)) 
  289.       {
  290.         Verb = (VerbStruct *) item->Pointer;  
  291.         XtFree(Verb->Command);
  292.         XtFree((char *) Verb); 
  293.       }
  294.     else
  295.       {
  296.         item = MidasAddItemToList(&Header->TempVerbList,verb);
  297.         pos = MidasFindItemPosInList(&Header->TempVerbList,item);
  298.         MidasSelectItemPosInList(&Header->TempVerbList,pos,FALSE);
  299.         CustomUpdatePositionsAdd(&Header->TempMenuList,pos,1);
  300.       }
  301.     XtFree(verb);
  302.  
  303.     Verb = XtNew(VerbStruct);
  304.     Verb->Command = command;
  305.     Verb->IsToggle = istoggle;
  306.  
  307.     Header->TempVerbList.Selected = item;
  308.     item->Pointer = Verb;
  309.     Header->Changed++;
  310.     CustomUpdateSensitivity(Header);
  311. }
  312. static void CustomSelVerb(w,closure,cbDataP)
  313.       Widget w; 
  314.       Opaque closure; 
  315.       XmListCallbackStruct *cbDataP;
  316. {
  317.     ListItem *item;
  318.     CustomHeader *Header = CustomFindHeader(w);
  319.     VerbStruct *Verb;
  320.     
  321.     item = MidasFindItemInListPos(&Header->TempVerbList,cbDataP->item_position); 
  322.     Header->TempVerbList.Selected = item;
  323.     XmTextSetString(Header->CustomVerbText,item->Entry);
  324.  
  325.     Verb = (VerbStruct *) item->Pointer;
  326.  
  327.     XmToggleButtonSetState(Header->CustomVerbIsToggle,Verb->IsToggle,FALSE);
  328.     XmTextSetString(Header->CustomCommandText,Verb->Command);
  329.  
  330.     CustomUpdateSensitivity(Header);
  331. }
  332. static void CustomDelVerb(w,closure,cbDataP)
  333.       Widget w; 
  334.       Opaque closure; 
  335.       XmAnyCallbackStruct *cbDataP;
  336. {
  337.     char *verb;
  338.     CustomHeader *Header = CustomFindHeader(w);
  339.     ListItem  *item = Header->TempVerbList.Selected; 
  340.     VerbStruct *Verb = (VerbStruct *) item->Pointer;
  341.  
  342.     int pos = MidasFindItemPosInList(&Header->TempVerbList,item);
  343.                            
  344.     XtFree(Verb->Command);
  345.   
  346.     CustomUpdatePositionsRemove(&Header->TempMenuList,pos,1);
  347.     MidasRemoveItemFromList(&Header->TempVerbList,item);
  348.                             
  349.     XmTextSetString(Header->CustomVerbText,"");
  350.     XmTextSetString(Header->CustomCommandText,"");
  351.     XmToggleButtonSetState(Header->CustomVerbIsToggle,FALSE,FALSE);
  352.     Header->TempVerbList.Selected = 0;
  353.     Header->Changed++;
  354.     CustomUpdateSensitivity(Header);
  355. }
  356. static void CustomAddMenu(w,closure,cbDataP)
  357.       Widget w; 
  358.       Opaque closure; 
  359.       XmAnyCallbackStruct *cbDataP;
  360. {
  361.     int pos;
  362.     char *menu;
  363.     ListItem *item;
  364.     CustomHeader *Header = CustomFindHeader(w);
  365.  
  366.     menu = XmTextGetString(Header->CustomMenuText);
  367.     XmTextSetString(Header->CustomMenuText,"");
  368.  
  369.     item = MidasAddItemToList(&Header->TempMenuList,menu);
  370.     pos = MidasFindItemPosInList(&Header->TempMenuList,item);
  371.     MidasSelectItemPosInList(&Header->TempMenuList,pos,FALSE);
  372.     CustomUpdatePositionsAdd(&Header->TempMenuList,pos,0);
  373.  
  374.     item->Pointer = MidasCreateEmptyList(menu);
  375.     Header->TempMenuList.Selected = item;
  376.     Header->Changed++;
  377.     CustomUpdateSensitivity(Header);
  378.     XtFree(menu);
  379. }
  380. static void CustomSelConfMenu(w,closure,cbDataP)
  381.       Widget w; 
  382.       Opaque closure; 
  383.       XmAnyCallbackStruct *cbDataP;
  384. {
  385.     char     label[100];
  386.     XmString string;
  387.     CustomHeader *Header = CustomFindHeader(w);
  388.  
  389.     strcpy(label,"Menu: "); 
  390.     if (Header->VMList!=0) MidasUnrealizeList(Header->VMList);  
  391.     Header->VMList = ((List *) Header->TempMenuList.Selected->Pointer);
  392.     MidasRealizeList(Header->VMList,Header->CustomVMList);
  393.     string = MidasCharToString(strcat(label,Header->TempMenuList.Selected->Entry));
  394.     CustomSetActiveMenu(Header,string);
  395.     XmStringFree(string);
  396.     CustomUpdateSensitivity(Header);
  397. }
  398. static void CustomSelMenu(w,closure,cbDataP)
  399.       Widget w; 
  400.       Opaque closure; 
  401.       XmListCallbackStruct *cbDataP;
  402. {
  403.     ListItem *item;
  404.     CustomHeader *Header = CustomFindHeader(w);
  405.     item = MidasFindItemInListPos(&Header->TempMenuList,cbDataP->item_position); 
  406.     Header->TempMenuList.Selected = item;
  407.     CustomUpdateSensitivity(Header);
  408. }
  409. static void CustomDelMenu(w,closure,cbDataP)
  410.       Widget w; 
  411.       Opaque closure; 
  412.       XmAnyCallbackStruct *cbDataP;
  413. {
  414.     char *menu;
  415.     CustomHeader *Header = CustomFindHeader(w);
  416.     int pos = MidasFindItemPosInList(&Header->TempMenuList,
  417.                                       Header->TempMenuList.Selected); 
  418.                             
  419.     CustomUpdatePositionsRemove(&Header->TempMenuList,pos,0);
  420.  
  421.     if (((List *) Header->TempMenuList.Selected->Pointer) == Header->VMList) 
  422.       {
  423.         XmString string;
  424.         MidasUnrealizeList(Header->VMList);  
  425.         Header->VMList=0;
  426.         string = MidasCharToString("No Menu Selected");
  427.         CustomSetActiveMenu(Header,string);
  428.         XmStringFree(string);
  429.       }
  430.     MidasDestroyList(Header->TempMenuList.Selected->Pointer);
  431.     Header->TempMenuList.Selected->Pointer = 0;
  432.     MidasRemoveItemFromList(&Header->TempMenuList,Header->TempMenuList.Selected); 
  433.     Header->TempMenuList.Selected = 0;
  434.     Header->Changed++;
  435.     CustomUpdateSensitivity(Header);
  436. }
  437. static void CustomVMAddSeparator(w,closure,cbDataP)
  438.       Widget w; 
  439.       Opaque closure; 
  440.       XmAnyCallbackStruct *cbDataP;
  441. {
  442.     ListItem *item; 
  443.     VerbInMenu *vm; 
  444.     CustomHeader *Header = CustomFindHeader(w);
  445.  
  446.     item = MidasAddItemToListPos(Header->VMList,"......",0);
  447.     MidasSelectItemPosInList(Header->VMList,0,FALSE);
  448.  
  449.     vm = XtNew(VerbInMenu);
  450.     vm->Menu = 0;
  451.     vm->Verb = 0;
  452.  
  453.     item->Pointer = vm;
  454.     Header->VMList->Selected = item;
  455.     Header->Changed++;
  456.     CustomUpdateSensitivity(Header);
  457. }
  458. static void CustomVMAddVerb(w,closure,cbDataP)
  459.       Widget w; 
  460.       Opaque closure; 
  461.       XmAnyCallbackStruct *cbDataP;
  462. {
  463.     char *verb; 
  464.     VerbInMenu *vm; 
  465.     ListItem *item; 
  466.     CustomHeader *Header = CustomFindHeader(w);
  467.  
  468.     verb = Header->TempVerbList.Selected->Entry;
  469.     item = MidasAddItemToListPos(Header->VMList,verb,0);
  470.     MidasSelectItemPosInList(Header->VMList,0,FALSE);
  471.  
  472.     vm = XtNew(VerbInMenu);
  473.     vm->Menu = 0;
  474.     vm->Verb = MidasFindItemPosInList(&Header->TempVerbList,
  475.                                        Header->TempVerbList.Selected);
  476.     item->Pointer = vm;
  477.  
  478.     Header->VMList->Selected = item;
  479.     Header->Changed++;
  480.     CustomUpdateSensitivity(Header);
  481. }
  482. static void CustomSelConfVerb(w,closure,cbDataP)
  483.       Widget w; 
  484.       Opaque closure; 
  485.       XmAnyCallbackStruct *cbDataP;
  486. {
  487.     CustomHeader *Header = CustomFindHeader(w);
  488.     if (XtIsSensitive(Header->CustomVMAddVerbButton)) 
  489.       CustomVMAddVerb(w,closure,(XmAnyCallbackStruct *) cbDataP);
  490. }
  491. static void CustomVMAddMenu(w,closure,cbDataP)
  492.       Widget w; 
  493.       Opaque closure; 
  494.       XmAnyCallbackStruct *cbDataP;
  495. {
  496.     char *menu, *arrow; 
  497.     VerbInMenu *vm; 
  498.     ListItem *item; 
  499.     CustomHeader *Header = CustomFindHeader(w);
  500.  
  501.     menu = Header->TempMenuList.Selected->Entry;
  502.     arrow = CustomAppendArrow(menu);
  503.     item = MidasAddItemToListPos(Header->VMList,arrow,0);
  504.     MidasSelectItemPosInList(Header->VMList,0,FALSE);
  505.     XtFree(arrow);
  506.    
  507.     vm = XtNew(VerbInMenu);
  508.     vm->Menu = MidasFindItemPosInList(&Header->TempMenuList,
  509.                                        Header->TempMenuList.Selected);
  510.     vm->Verb = 0;
  511.    
  512.     item->Pointer = vm;
  513.  
  514.     Header->VMList->Selected = item;
  515.     Header->Changed++;
  516.     CustomUpdateSensitivity(Header);
  517. }
  518. static void CustomVMSel(w,closure,cbDataP)
  519.       Widget w; 
  520.       Opaque closure; 
  521.       XmListCallbackStruct *cbDataP;
  522. {
  523.     ListItem *item;
  524.     CustomHeader *Header = CustomFindHeader(w);
  525.  
  526.     item = MidasFindItemInListPos(Header->VMList,cbDataP->item_position);
  527.     Header->VMList->Selected = item;
  528.     CustomUpdateSensitivity(Header);
  529. }
  530. static void CustomVMSelConf(w,closure,cbDataP)
  531.       Widget w; 
  532.       Opaque closure; 
  533.       XmListCallbackStruct *cbDataP;
  534. {
  535.     VerbInMenu *vm;
  536.     ListItem *item;
  537.     CustomHeader *Header = CustomFindHeader(w);
  538.  
  539.     item = MidasFindItemInListPos(Header->VMList,cbDataP->item_position);
  540.     vm = ((VerbInMenu *) item->Pointer);
  541.     if      (vm->Verb != 0) 
  542.       { 
  543.         ListItem *verb = MidasFindItemInListPos(&Header->TempVerbList,vm->Verb);
  544.         XmString string = MidasCharToString(verb->Entry);
  545.         XmListSelectItem(Header->CustomVerbList,string,1);
  546.         XmStringFree(string);
  547.       }
  548.     else if (vm->Menu != 0) 
  549.       {
  550.         ListItem *menu = MidasFindItemInListPos(&Header->TempMenuList,vm->Menu);
  551.         XmString string = MidasCharToString(menu->Entry);
  552.         XmListSelectItem(Header->CustomMenuList,string,1);
  553.         XmStringFree(string);
  554.       }
  555. }
  556. static void CustomVMDel(w,closure,cbDataP)
  557.       Widget w; 
  558.       Opaque closure; 
  559.       XmAnyCallbackStruct *cbDataP;
  560. {
  561.     char *menu;
  562.     ListItem *item;
  563.     CustomHeader *Header = CustomFindHeader(w);
  564.  
  565.     MidasRemoveItemFromList(Header->VMList,Header->VMList->Selected); 
  566.     Header->VMList->Selected = 0;
  567.     Header->Changed++;
  568.     CustomUpdateSensitivity(Header);
  569. }
  570. static void CustomMoveUp(Header,item,dir)
  571.       CustomHeader *Header;
  572.       ListItem     *item;
  573.       int           dir;
  574. {
  575.     XmString NewItems[2];
  576.  
  577.     ListItem *i;
  578.     ListItem *swap = item->Prev;
  579.     int position=0;
  580.  
  581.     for (i = Header->VMList->First; i != 0; i = i->Next) 
  582.       {
  583.         position++;
  584.         if (i == item) break;
  585.       }
  586.  
  587.     NewItems[0] = MidasCharToString(item->Entry); 
  588.     NewItems[1] = MidasCharToString(swap->Entry); 
  589.     
  590.     XmListReplaceItemsPos(Header->VMList->W,NewItems,2,--position);
  591.  
  592.     XmStringFree(NewItems[0]);
  593.     XmStringFree(NewItems[1]);
  594.  
  595.     if (dir) 
  596.       {
  597.         XmListDeselectPos(Header->VMList->W,position);
  598.         XmListSelectPos(Header->VMList->W,position+1,0);
  599.       }
  600.     else 
  601.       {
  602.         XmListSelectPos(Header->VMList->W,position,0);
  603.         XmListDeselectPos(Header->VMList->W,position+1);
  604.       }
  605.  
  606.     if (Header->VMList->First == swap) Header->VMList->First = item; 
  607.     else                               swap->Prev->Next = item;
  608.     if (Header->VMList->Last  == item) Header->VMList->Last  = swap; 
  609.     else                               item->Next->Prev = swap;
  610.     item->Prev = swap->Prev;
  611.     swap->Next = item->Next;
  612.     item->Next = swap;
  613.     swap->Prev = item;
  614.     Header->Changed++;
  615.     CustomUpdateSensitivity(Header);
  616. }
  617. static void CustomVMUp(w,closure,cbDataP)
  618.       Widget w; 
  619.       Opaque closure; 
  620.       XmAnyCallbackStruct *cbDataP;
  621. {
  622.     CustomHeader *Header = CustomFindHeader(w);
  623.     CustomMoveUp(Header,Header->VMList->Selected,0);
  624. }
  625. static void CustomVMDown(w,closure,cbDataP)
  626.       Widget w; 
  627.       Opaque closure; 
  628.       XmAnyCallbackStruct *cbDataP;
  629. {
  630.     CustomHeader *Header = CustomFindHeader(w);
  631.     CustomMoveUp(Header,Header->VMList->Selected->Next,1);
  632. }
  633. static void CustomDispatchCommand(w,tag,cbDataP)
  634.       Widget w; 
  635.       Opaque tag; 
  636.       XmAnyCallbackStruct *cbDataP;
  637. {
  638.    MidasDispatchCommandCallback(w,tag,cbDataP);
  639. }
  640. static void CustomCreateCallback(w,tag,cbDataP)
  641.       Widget w; 
  642.       int *tag; 
  643.       XmAnyCallbackStruct *cbDataP;
  644. {
  645.     ListItem *item = CustomHeaders.Selected;
  646.     CustomHeader *Header = item->Pointer;
  647.  
  648.     if      (*tag ==  1) Header->CustomCommandText       = w; 
  649.     else if (*tag ==  2) Header->CustomVMUpButton        = w;
  650.     else if (*tag ==  3) Header->CustomVMDownButton      = w;
  651.     else if (*tag ==  4) Header->CustomVMAddVerbButton   = w;
  652.     else if (*tag ==  5) Header->CustomVMAddMenuButton   = w;
  653.     else if (*tag ==  6) Header->CustomVMSeparatorButton = w;
  654.     else if (*tag ==  7) Header->CustomVMRemoveButton    = w;
  655.     else if (*tag ==  8) Header->CustomVMList            = w;
  656.     else if (*tag ==  9) Header->CustomOKButton          = w;
  657.     else if (*tag == 10) Header->CustomApplyButton       = w;
  658.     else if (*tag == 11) Header->CustomCancelButton      = w;
  659.     else if (*tag == 12) Header->CustomResetButton       = w;
  660.     else if (*tag == 13) Header->CustomVerbList          = w;
  661.     else if (*tag == 14) Header->CustomVerbText          = w;
  662.     else if (*tag == 15) Header->CustomVerbAddButton     = w;
  663.     else if (*tag == 16) Header->CustomVerbDeleteButton  = w;
  664.     else if (*tag == 17) Header->CustomMenuList          = w;
  665.     else if (*tag == 18) Header->CustomMenuText          = w;
  666.     else if (*tag == 19) Header->CustomMenuAddButton     = w;
  667.     else if (*tag == 20) Header->CustomMenuDeleteButton  = w;
  668.     else if (*tag == 21) Header->CustomVMActiveLabel     = w;
  669.     else if (*tag == 22) Header->CustomVerbIsToggle      = w;
  670. }                      
  671. static void CustomDestroyMenu(w)
  672.       Widget w;
  673. {
  674.       Widget *list = DXmChildren(w);
  675.       int n = DXmNumChildren(w);
  676.  
  677.       for (; n > 0; n--) 
  678.         { 
  679.           XtUnmanageChild(*list);
  680.           XtDestroyWidget(*list);
  681.           list++;
  682.         }
  683. }
  684. static char *strtrn(in,from,to)
  685. char *in; 
  686. char from; 
  687. char to;
  688. {
  689.       char *p = in;
  690.       for (; *p != 0; p++) if (*p == from) *p = to;
  691.       return in;
  692. }
  693. static void CustomBuildMenu(Header,w,menu)
  694.       CustomHeader *Header;
  695.       Widget w; 
  696.       List   *menu;
  697. {
  698.       Widget child[4000];
  699.       ListItem *j;
  700.       int m=0;
  701.  
  702.       for (j = menu->First; j != 0; j = j->Next)
  703.         {
  704.           VerbInMenu *vm = ((VerbInMenu *) j->Pointer);
  705.           if (vm->Verb != 0) 
  706.             {
  707.               ListItem *verb = MidasFindItemInListPos(&Header->VerbList,vm->Verb);
  708.               XmString verbname = MidasCharToString(verb->Entry);
  709.               VerbStruct *Verb = (VerbStruct *) verb->Pointer;
  710.  
  711.               Arg args[10];
  712.               int n = 0;          
  713.               char *name = strtrn(XtNewString(verb->Entry),' ','_');              
  714.  
  715.               strtrn(name,'.','_');          
  716.  
  717.               if (Verb->IsToggle)
  718.                 {
  719.                   XtSetArg(args[n],XmNlabelString, verbname); n++;
  720.                   child[m] = XmCreateToggleButtonGadget(w,name,args,n);
  721.                   MidasSetupWidget(child[m]);
  722.                   XtAddCallback(child[m++],XmNvalueChangedCallback,
  723.                                 CustomDispatchCommand,Verb->Command);
  724.                  }
  725.               else
  726.                 {
  727.                   XtSetArg(args[n],XmNlabelString, verbname); n++;
  728.                   child[m] = XmCreatePushButtonGadget(w,name,args,n);
  729.                   MidasSetupWidget(child[m]);
  730.                   XtAddCallback(child[m++],XmNactivateCallback,
  731.                                 CustomDispatchCommand,Verb->Command);
  732.                 } 
  733.               XtFree(name);
  734.               XmStringFree(verbname);
  735.             }
  736.           else if (vm->Menu != 0) 
  737.             {
  738.               ListItem *menu = MidasFindItemInListPos(&Header->MenuList,vm->Menu);
  739.               XmString menuname = MidasCharToString(menu->Entry);
  740.               char *name = strtrn(XtNewString(menu->Entry),' ','_');
  741.               Widget submenu = XmCreatePulldownMenu(w,name,NULL,0);
  742.               int n = 0;
  743.               Arg args[10];
  744.               XtSetArg(args[n],XmNlabelString , menuname ); n++;
  745.               XtSetArg(args[n],XmNsubMenuId   , submenu  ); n++;
  746.               child[m] = XmCreateCascadeButtonGadget(w,name,args,n);
  747. /*
  748.  *  If the last item in a menu is a HELP menu, force it to be right aligned
  749.  */
  750.  
  751.               if (j->Next == NULL && strcmp(name,"Help")==0)
  752.                 {
  753.                   n = 0;
  754.                   XtSetArg(args[n],XmNmenuHelpWidget,child[m]); n++;
  755.                   XtSetValues(w,args,n);
  756.                 }
  757.  
  758.               MidasSetupWidget(submenu);
  759.               MidasSetupWidget(child[m++]);
  760.               XtFree(name);
  761.               XmStringFree(menuname);
  762.  
  763.               CustomBuildMenu(Header,submenu,menu->Pointer); 
  764.             }
  765.           else 
  766.             {
  767.               child[m++] = XmCreateSeparatorGadget(w," ",NULL,0);
  768.             }
  769.         }
  770.       XtManageChildren(child,m);
  771. }
  772. static void CustomUpdateMenus(Header)
  773.     CustomHeader *Header;
  774. {
  775.     ListItem *connect = Header->ConnectList.First;
  776.     for (; connect != 0 ; connect = connect->Next )
  777.       {
  778.         Link *link = connect->Pointer;
  779.         ListItem *menu = MidasFindItemInList(&Header->MenuList,connect->Entry);
  780.         CustomDestroyMenu(link->Widget);
  781.         CustomBuildMenu(Header,link->Widget,menu->Pointer);
  782.       }
  783. }
  784. static VerbStruct *CustomCopyVerbListElement(Old)
  785.     VerbStruct *Old;
  786. { 
  787.     VerbStruct *New = XtNew(VerbStruct);
  788.  
  789.     New->IsToggle = Old->IsToggle;
  790.     New->Command = XtNewString(Old->Command);  
  791.  
  792.     return New;
  793. }
  794. static VerbInMenu *CustomCopyVMListElement(vm)
  795.     VerbInMenu *vm;
  796. {
  797.     return (VerbInMenu *) memcpy(XtMalloc(sizeof(VerbInMenu)),vm,sizeof(VerbInMenu));
  798. }
  799. static List *CustomCopyMenuListElement(L)
  800.     List *L;
  801. {
  802.     List *New = MidasCreateEmptyList("");
  803.     MidasCopyList(L,New,(MidasCopyListRtn)CustomCopyVMListElement);
  804.     return New;
  805. }
  806. static void CustomCopyVerbList(Old,New)
  807.     List *Old;
  808.     List *New;
  809. {
  810.     MidasCopyList(Old,New,(MidasCopyListRtn)CustomCopyVerbListElement);
  811. }
  812. static void CustomCopyMenuList(Old,New)
  813.     List *Old;
  814.     List *New;
  815. {
  816.     MidasCopyList(Old,New,(MidasCopyListRtn)CustomCopyMenuListElement);
  817. }
  818. static void CustomCleanup(Header)
  819.    CustomHeader *Header;
  820. {
  821.     XmString string;
  822.     if (Header->VMList != 0) MidasUnrealizeList(Header->VMList);  
  823.     MidasUnrealizeList(&Header->TempVerbList);
  824.     MidasUnrealizeList(&Header->TempMenuList);
  825.     Header->VMList=0;
  826.     string = MidasCharToString("No Menu Selected");
  827.     CustomSetActiveMenu(Header,string);
  828.     XmStringFree(string);
  829.     XmTextSetString(Header->CustomVerbText,"");
  830.     XmTextSetString(Header->CustomMenuText,"");
  831.     XmTextSetString(Header->CustomCommandText,"");
  832. }
  833. static void CustomApply(w,tag,cbDataP)
  834.       Widget w; 
  835.       int    *tag; 
  836.       XmSelectionBoxCallbackStruct *cbDataP;
  837. {
  838.     ListItem *i;
  839.     CustomHeader *Header = CustomFindHeader(w);
  840.     Header->Changed = 0;
  841.     Header->Modified++;
  842.  
  843.     for (i = Header->MenuList.First ; i != 0 ; i = i->Next )
  844.       {
  845.         MidasDestroyList(i->Pointer);
  846.         i->Pointer = 0;
  847.       }
  848.     for (i = Header->VerbList.First ; i != 0 ; i = i->Next )
  849.       {
  850.         VerbStruct *Verb = (VerbStruct *) i->Pointer;
  851.         XtFree(Verb->Command);
  852.         XtFree((char *) Verb);
  853.         i->Pointer = 0;
  854.       }
  855.     MidasEmptyList(&Header->VerbList);
  856.     MidasEmptyList(&Header->MenuList);
  857.  
  858.     Header->VerbList = NullList;
  859.     Header->MenuList = NullList;
  860.  
  861.     CustomCopyVerbList(&Header->TempVerbList,&Header->VerbList);
  862.     CustomCopyMenuList(&Header->TempMenuList,&Header->MenuList);
  863.  
  864.     CustomUpdateMenus(Header);
  865.  
  866.     CustomUpdateSensitivity(Header);
  867. }
  868. static void CustomReset(w,tag,cbDataP)
  869.       Widget w; 
  870.       int    *tag; 
  871.       XmSelectionBoxCallbackStruct *cbDataP;
  872. {
  873.     CustomHeader *Header = CustomFindHeader(w);
  874.     ListItem *i;
  875.  
  876.     CustomCleanup(Header);
  877.  
  878.     for (i = Header->TempMenuList.First ; i != 0 ; i = i->Next )
  879.       {
  880.         MidasDestroyList(i->Pointer);
  881.         i->Pointer = 0;
  882.       }
  883.     for (i = Header->TempVerbList.First ; i != 0 ; i = i->Next )
  884.       {
  885.         VerbStruct *Verb = (VerbStruct *) i->Pointer;
  886.         XtFree(Verb->Command);
  887.         XtFree((char *) Verb);
  888.         i->Pointer = 0;
  889.       }
  890.  
  891.     MidasEmptyList(&Header->TempVerbList);
  892.     MidasEmptyList(&Header->TempMenuList);
  893.  
  894.     Header->TempVerbList = NullList;
  895.     Header->TempMenuList = NullList;
  896.  
  897.     CustomCopyVerbList(&Header->VerbList,&Header->TempVerbList);
  898.     CustomCopyMenuList(&Header->MenuList,&Header->TempMenuList);
  899.  
  900.     MidasRealizeList(&Header->TempVerbList,Header->CustomVerbList);
  901.     MidasRealizeList(&Header->TempMenuList,Header->CustomMenuList);
  902.     Header->Changed = 0;
  903.     CustomUpdateSensitivity(Header);
  904. }
  905. static void CustomCancel(w,tag,cbDataP)
  906.       Widget w; 
  907.       int    *tag; 
  908.       XmSelectionBoxCallbackStruct *cbDataP;
  909. {
  910.     ListItem *i;
  911.     CustomHeader *Header = CustomFindHeader(w);
  912.  
  913.     XtUnmanageChild(Header->Fetched);
  914.     CustomCleanup(Header);
  915.  
  916.     for (i = Header->TempMenuList.First ; i != 0 ; i = i->Next )
  917.       {
  918.         MidasDestroyList(i->Pointer);
  919.         i->Pointer = 0;
  920.       }
  921.     for (i = Header->TempVerbList.First ; i != 0 ; i = i->Next )
  922.       {
  923.         VerbStruct *Verb = (VerbStruct *) i->Pointer;
  924.         XtFree(Verb->Command);
  925.         XtFree((char *) Verb);
  926.         i->Pointer = 0;
  927.       }
  928.     MidasEmptyList(&Header->TempVerbList);
  929.     MidasEmptyList(&Header->TempMenuList);
  930.  
  931.     Header->TempVerbList = NullList;
  932.     Header->TempMenuList = NullList;
  933.  
  934. }
  935. static void CustomOk(w,tag,cbDataP)
  936.       Widget w; 
  937.       int    *tag; 
  938.       XmSelectionBoxCallbackStruct *cbDataP;
  939. {
  940.     CustomHeader *Header = CustomFindHeader(w);
  941.     ListItem *i;
  942.  
  943.     CustomCleanup(Header);
  944.  
  945.     if (Header->Changed != 0)
  946.       {  
  947.         for (i = Header->MenuList.First ; i != 0 ; i = i->Next )
  948.           {
  949.             MidasDestroyList(i->Pointer);
  950.             i->Pointer = 0;
  951.           }
  952.         for (i = Header->VerbList.First ; i != 0 ; i = i->Next )
  953.           {
  954.             VerbStruct *Verb = (VerbStruct *) i->Pointer;
  955.             XtFree(Verb->Command);
  956.             XtFree((char *) Verb);
  957.             i->Pointer = 0;
  958.           }
  959.         MidasEmptyList(&Header->VerbList);
  960.         MidasEmptyList(&Header->MenuList);
  961.  
  962.         Header->VerbList = Header->TempVerbList;
  963.         Header->MenuList = Header->TempMenuList;
  964.  
  965.         CustomUpdateMenus(Header);
  966.         Header->Modified++;
  967.       }
  968.     else 
  969.       {
  970.         for (i = Header->TempMenuList.First ; i != 0 ; i = i->Next )
  971.           {
  972.             MidasDestroyList(i->Pointer);
  973.             i->Pointer = 0;
  974.           }
  975.         for (i = Header->TempVerbList.First ; i != 0 ; i = i->Next )
  976.           {
  977.             VerbStruct *Verb = (VerbStruct *) i->Pointer;
  978.             XtFree(Verb->Command);
  979.             XtFree((char *) Verb);
  980.             i->Pointer = 0;
  981.           }
  982.         MidasEmptyList(&Header->TempVerbList);
  983.         MidasEmptyList(&Header->TempMenuList);
  984.       }
  985.     Header->TempVerbList = NullList;
  986.     Header->TempVerbList = NullList;
  987.  
  988.     XtUnmanageChild(Header->Fetched);
  989. }
  990. static void CustomWrite(Header,Name)
  991.     CustomHeader *Header;
  992.     char *Name;
  993. {
  994.     ListItem *i,*j;
  995.     List *menu;
  996.     char list[4096];
  997.     char value[4096];
  998.     char specifier[80];
  999.     char *l = list;
  1000.     MidasShell *ms = MidasGetShell(Header->Parent);
  1001.     XrmDatabase *database = &ms->Database;
  1002.     int n= 0 ;
  1003.  
  1004.     for (i = Header->VerbList.First; i != 0; i = i->Next)
  1005.       {
  1006.         VerbStruct *Verb = (VerbStruct *) i->Pointer; 
  1007.         strcpy(l,i->Entry);
  1008.  
  1009.         l += strlen(i->Entry);
  1010.         *l++ = '#';
  1011.  
  1012.         sprintf(specifier,"CUSTOM.%s.Verb.%d",Name,++n);
  1013.  
  1014.         if (Verb->IsToggle) sprintf(value,"#%s",Verb->Command);
  1015.         else                sprintf(value,"%s" ,Verb->Command);
  1016.  
  1017.         XrmPutStringResource(database,specifier,value);
  1018.       }
  1019.  
  1020.     *(--l) = '\0';
  1021.     sprintf(specifier,"CUSTOM.%s.Verbs",Name);
  1022.     XrmPutStringResource(database,specifier,list);
  1023.  
  1024.     l = list;
  1025.     n = 0; 
  1026.     
  1027.     for (i = Header->MenuList.First; i != 0; i = i->Next)
  1028.       {
  1029.         char *v = value;
  1030.  
  1031.         menu = i->Pointer;
  1032.  
  1033.         strcpy(l,i->Entry);
  1034.         l += strlen(i->Entry);
  1035.         *l++ = '#';
  1036.  
  1037.         for (j = menu->First; j != 0; j = j->Next)
  1038.           {
  1039.             VerbInMenu *vm = ((VerbInMenu *) j->Pointer);
  1040.             int pos = 0;
  1041.  
  1042.             if      (vm->Verb != 0) pos = vm->Verb;
  1043.             else if (vm->Menu != 0) pos = -vm->Menu;
  1044.  
  1045.             sprintf(v,"%s\\%d#",j->Entry,pos);
  1046.             v += strlen(v);
  1047.           }
  1048.         *(--v) = '\0';
  1049.         sprintf(specifier,"CUSTOM.%s.Menu.%d",Name,++n);
  1050.         XrmPutStringResource(database,specifier,value);
  1051.       }
  1052.  
  1053.     *(--l) = '\0';
  1054.     sprintf(specifier,"CUSTOM.%s.Menus",Name);
  1055.     XrmPutStringResource(database,specifier,list);
  1056.  
  1057.     ms->Changes++;
  1058.     Header->Modified = 0;
  1059. }
  1060. static void CustomReadOld(Header,Name,UserDefaults)
  1061.     CustomHeader *Header;
  1062.     char         *Name;
  1063.     int          UserDefaults;
  1064. {
  1065.     char buffer[4000] , name[80];
  1066.     FILE *file;
  1067.  
  1068.     if (UserDefaults)
  1069.       {
  1070. #ifdef VAX
  1071.         sprintf(name,"DECW$USER_DEFAULTS:MIDAS_%s.DAT",Name);
  1072. #else
  1073.         sprintf(name,".Midas_%src",Name);
  1074. #endif
  1075.         file = fopen(name,"r");
  1076.       }
  1077.     if (file == 0)
  1078.       {
  1079.         sprintf(name,"DECW$SYSTEM_DEFAULTS:MIDAS_%s.DAT",Name);
  1080.         file = fopen(name,"r");
  1081.       }
  1082.     if (file == 0)
  1083.        file = fopen("DECW$SYSTEM_DEFAULTS:MIDAS_CUSTOM.DAT","r");
  1084.  
  1085.     if (file == 0) MidasError("Could not open customization file for %s",Name);
  1086.     
  1087.     for (;;) 
  1088.       {
  1089.         int c = fgetc(file);
  1090.         if (c == EOF) break;
  1091.         if (c == '$')
  1092.           {
  1093.             int i,j,l;
  1094.             char type[6],*p;
  1095.  
  1096.             p = type;
  1097.             *p++ = fgetc(file);
  1098.             *p++ = fgetc(file);
  1099.             *p++ = fgetc(file);
  1100.             *p++ = fgetc(file);
  1101.             *p++ = fgetc(file);
  1102.             *p = '\0';
  1103.  
  1104.             for (l=0;;l++)
  1105.               {
  1106.                  c = fgetc(file);
  1107.                  buffer[l] = c;
  1108.  
  1109.                  if (c == '{') j=l;
  1110.                  if (c == '}' | c == EOF) break;
  1111.               }
  1112.  
  1113.             i = 1;
  1114.             buffer[j-1] = '\0';
  1115.             j += 2;
  1116.  
  1117.             if (strcmp(type,"Verb:") == 0)
  1118.               {
  1119.                 VerbStruct *Verb = XtNew(VerbStruct); 
  1120.                 ListItem *item; 
  1121.                 if (buffer[i]=='#') 
  1122.                   {
  1123.                     i++;
  1124.                     Verb->IsToggle = TRUE;
  1125.                   }
  1126.                 else Verb->IsToggle = FALSE;       
  1127.                 item = MidasAddItemToList(&Header->VerbList,&buffer[i]);
  1128.                 buffer[l-1] = '\0';
  1129.                 item->Pointer = Verb;
  1130.                 Verb->Command = XtNewString(&buffer[j]);
  1131.               }         
  1132.             else if (strcmp(type,"Menu:") == 0)
  1133.               {
  1134.                 int k;
  1135.                 List *list;
  1136.  
  1137.                 ListItem *item = MidasAddItemToListPos(&Header->MenuList,&buffer[i],0);
  1138.  
  1139.                 list = XtNew(List);
  1140.                 list->First    = 0;
  1141.                 list->Last     = 0;
  1142.                 list->Selected = 0;
  1143.                 list->W        = 0;
  1144.                 item->Pointer = list;
  1145.                 for (;;)
  1146.                   {
  1147.                     VerbInMenu *vm;
  1148.                     int pos;
  1149.  
  1150.                     for (;buffer[j]==' ';j++);
  1151.                     for (k=j; buffer[k]!='\\' && buffer[k]!='}'; k++);
  1152.                     if (buffer[k]=='}') break;
  1153.                     buffer[k]='\0';
  1154.                     item = MidasAddItemToListPos(list,&buffer[j],0);
  1155.                     vm = XtNew(VerbInMenu);
  1156.                     item->Pointer = vm;
  1157.                     vm->Menu = 0; 
  1158.                     vm->Verb = 0; 
  1159.                     j = k+1;
  1160.                     for (k=j; buffer[k]!='\n'; k++);
  1161.                     buffer[k]='\0';
  1162.                     pos = atoi(&buffer[j]);
  1163.                     if      (pos > 0) vm->Verb = pos;
  1164.                     else if (pos < 0) vm->Menu = -pos;
  1165.                     j = k+1;
  1166.                   }
  1167.               }
  1168.           }
  1169.       }
  1170.     fclose(file);
  1171. }
  1172. static void CustomRead(Header,Name,UserDefaults) 
  1173.     CustomHeader *Header;
  1174.     char         *Name;
  1175.     int          UserDefaults;
  1176. {
  1177.     XrmDatabase database = XtDatabase(XtDisplay(Header->Parent));
  1178.     char specifier[80];
  1179.     char *type;
  1180.     XrmRepresentation rep;
  1181.     char *Verbs, *verb;
  1182.     char *Menus, *menu;
  1183.     XrmValue value;
  1184.     Boolean found;
  1185.     int n = 0;
  1186.     XrmHashTable root[10]; 
  1187.     XrmQuark     quarks[3]; 
  1188.  
  1189.  
  1190. /*
  1191.  * Start by reading the lists of verbs and menus
  1192.  */
  1193.     sprintf(specifier,"CUSTOM.%s.Verbs",Name);
  1194.  
  1195.     found = XrmGetResource(database,specifier,specifier,&type,&value);
  1196.     
  1197.     if (!found)
  1198.       {
  1199.         CustomReadOld(Header,Name,UserDefaults);
  1200.         return;
  1201.       }
  1202.     Verbs = XtNewString(value.addr);
  1203.  
  1204.     sprintf(specifier,"CUSTOM.%s.Menus",Name);
  1205.     found = XrmGetResource(database,specifier,specifier,&type,&value);
  1206.     Menus = XtNewString(value.addr);
  1207.     
  1208.     sprintf(specifier,"CUSTOM.%s.Verb",Name);
  1209.     XrmStringToNameList(specifier,quarks);
  1210.     
  1211.     XrmQGetSearchList(database,quarks,quarks,root,XtNumber(root)); 
  1212.  
  1213.     for (verb = strtok(Verbs,"#"); verb != NULL; verb = strtok(NULL,"#"))
  1214.       {
  1215.         VerbStruct *Verb = XtNew(VerbStruct); 
  1216.         ListItem *item = MidasAddItemToListPos(&Header->VerbList,verb,0); 
  1217.         char name[8];
  1218.         char *command;
  1219.         
  1220.         sprintf(name,"%d",++n);
  1221.         XrmQGetSearchResource(root,XrmStringToName(name),XrmStringToClass(name),&rep,&value);
  1222.         command = value.addr;
  1223.  
  1224.         if (Verb->IsToggle = (*command == '#')) command++; 
  1225.  
  1226.         item->Pointer = Verb;
  1227.         Verb->Command = XtNewString(command);
  1228.       } 
  1229.     
  1230.     n = 0;
  1231.     sprintf(specifier,"CUSTOM.%s.Menu",Name);
  1232.     XrmStringToNameList(specifier,quarks);
  1233.     
  1234.     XrmQGetSearchList(database,quarks,quarks,root,XtNumber(root)); 
  1235.  
  1236.     for (menu = strtok(Menus,"#"); menu != NULL; menu = strtok(NULL,"#"))
  1237.       {
  1238.         char *menuitems, *p;
  1239.         char name[8];
  1240.         List *list = MidasCreateEmptyList("");
  1241.         ListItem *item = MidasAddItemToListPos(&Header->MenuList,menu,0);
  1242.         item->Pointer = list;
  1243.  
  1244.         sprintf(name,"%d",++n);
  1245.         XrmQGetSearchResource(root,XrmStringToName(name),XrmStringToClass(name),&rep,&value);
  1246.         menuitems = XtNewString(value.addr);
  1247.  
  1248.         for (p = menuitems; *p != '\0'; p++)
  1249.           {
  1250.             VerbInMenu *vm = XtNew(VerbInMenu);
  1251.             int pos;
  1252.             ListItem *item;
  1253.  
  1254.             for (verb = p; *p != '\\'; p++);
  1255.             *p = '\0';
  1256.  
  1257.             item = MidasAddItemToListPos(list,verb,0);
  1258.             item->Pointer = vm;
  1259.  
  1260.             vm->Menu = 0; 
  1261.             vm->Verb = 0; 
  1262.  
  1263.             for (verb = ++p; *p != '#' && *p != '\0'; p++);
  1264.  
  1265.             pos = atoi(verb);
  1266.             if      (pos > 0) vm->Verb = pos;
  1267.             else if (pos < 0) vm->Menu = -pos;
  1268.  
  1269.             if (*p == '\0') break;
  1270.           }
  1271.         XtFree(menuitems);
  1272.       } 
  1273.  
  1274.     XtFree(Verbs);
  1275.     XtFree(Menus);
  1276. }
  1277. static void CustomDisconnect(w,connect,cbDataP)
  1278.       Widget w; 
  1279.       ListItem *connect; 
  1280.       XmSelectionBoxCallbackStruct *cbDataP;
  1281. {
  1282.   Link *link = connect->Pointer;
  1283.   CustomHeader *Header = link->Header;
  1284.   MidasRemoveItemFromList(&Header->ConnectList,connect);
  1285. }
  1286. void CustomWriteUser(name,entry)
  1287.       char   *name;
  1288.       char   *entry;
  1289. {
  1290.     CustomHeader *Header;
  1291.     ListItem *item = MidasFindItemInList(&CustomHeaders,name);
  1292.     char *fname;
  1293.  
  1294.     if (item == 0) return;
  1295.  
  1296.     Header = item->Pointer;
  1297.     if (entry==0) fname=name;
  1298.     else          fname=entry;
  1299.  
  1300.     CustomWrite(Header,fname);
  1301. }
  1302. void CustomReadUser(name,entry)
  1303.       char   *name;
  1304.       char   *entry;
  1305. {
  1306.     CustomHeader *Header;
  1307.     ListItem *item = MidasFindItemInList(&CustomHeaders,name);
  1308.     char *fname;
  1309.  
  1310.     if (item == 0) return;
  1311.  
  1312.     Header = item->Pointer;
  1313.     if (entry==0) fname=name;
  1314.     else          fname=entry;
  1315.  
  1316.     CustomRead(Header,fname,1);
  1317. }
  1318. void CustomReadSystem(name,entry)
  1319.       char   *name;
  1320.       char   *entry;
  1321. {
  1322.     CustomHeader *Header;
  1323.     ListItem *item = MidasFindItemInList(&CustomHeaders,name);
  1324.     char *fname;
  1325.  
  1326.     if (item == 0) return;
  1327.  
  1328.     Header = item->Pointer;
  1329.     if (entry==0) fname=name;
  1330.     else          fname=entry;
  1331.  
  1332.     CustomRead(Header,fname,0);
  1333. }
  1334. void CustomConnect(name,entry,w)
  1335.       char   *name;
  1336.       char   *entry;
  1337.       Widget w;
  1338. {
  1339.     CustomHeader *Header;
  1340.     ListItem *item = MidasFindItemInList(&CustomHeaders,name);
  1341.     ListItem *menu, *connect; 
  1342.     Link *link;
  1343.     int pos;
  1344.  
  1345.     if (item == 0) return;
  1346.  
  1347.     Header = item->Pointer;
  1348.     menu = MidasFindItemInList(&Header->MenuList,entry);
  1349.     if (menu==0)
  1350.       {
  1351.         menu = MidasAddItemToList(&Header->MenuList,entry);
  1352.         pos = MidasFindItemPosInList(&Header->MenuList,menu);
  1353.         CustomUpdatePositionsAdd(&Header->MenuList,pos,0);
  1354.         menu->Pointer = MidasCreateEmptyList("");
  1355.       }
  1356.     else
  1357.       {
  1358.         CustomBuildMenu(Header,w,menu->Pointer);
  1359.       }
  1360.  
  1361.     connect = MidasAddItemToListPos(&Header->ConnectList,entry,0);
  1362.     link = XtNew(Link);
  1363.     connect->Pointer = link;
  1364.     link->Widget = w;
  1365.     link->Header = Header;
  1366.     XtAddCallback(w,XmNdestroyCallback,CustomDisconnect,(XtPointer) connect);
  1367. }
  1368. void CustomPopup(name)
  1369.       char   *name;
  1370. {
  1371.     CustomHeader *Header;
  1372.     ListItem *item = MidasFindItemInList(&CustomHeaders,name);
  1373.  
  1374.     if (item == 0) return;
  1375.  
  1376.     Header = item->Pointer;
  1377.  
  1378.     if (Header->Fetched == 0)
  1379.       {
  1380.         int n = 0;
  1381.         Arg args[10];
  1382.         XtSetArg(args[n],XmNuserData , Header); n++;
  1383.         CustomHeaders.Selected = item;
  1384.         Header->Fetched = MidasFetch("Midas_Custom",Header->Parent);
  1385.         XtSetValues(Header->Fetched,args,n); 
  1386.       }
  1387.     if (XtIsManaged(Header->Fetched) == 0)
  1388.       {
  1389.         Header->TempVerbList = NullList;
  1390.         Header->TempMenuList = NullList;
  1391.         CustomCopyVerbList(&Header->VerbList,&Header->TempVerbList);
  1392.         CustomCopyMenuList(&Header->MenuList,&Header->TempMenuList);
  1393.         MidasRealizeList(&Header->TempVerbList,Header->CustomVerbList);
  1394.         MidasRealizeList(&Header->TempMenuList,Header->CustomMenuList);
  1395.         Header->Changed = 0;
  1396.         XtManageChild(Header->Fetched);
  1397.       }
  1398.     CustomUpdateSensitivity(Header);
  1399. }
  1400. void CustomCreate(name,parent)
  1401.       char   *name;
  1402.       Widget parent;
  1403. {
  1404.     CustomHeader *NewHeader;
  1405.     ListItem *NewItem;
  1406.  
  1407.     if (MidasFindItemInList(&CustomHeaders,name)) return;
  1408.  
  1409.     NewItem   =  MidasAddItemToList(&CustomHeaders,name);
  1410.  
  1411.     NewHeader = XtNew(CustomHeader);
  1412.     NewItem->Pointer = NewHeader;
  1413.  
  1414.     NewHeader->Modified     = 0;
  1415.     NewHeader->Fetched      = 0;
  1416.     NewHeader->Parent       = parent;
  1417.     NewHeader->MenuList     = NullList;
  1418.     NewHeader->VerbList     = NullList;
  1419.     NewHeader->TempMenuList = NullList;
  1420.     NewHeader->TempVerbList = NullList;
  1421.     NewHeader->VMList       = 0;
  1422.     NewHeader->ConnectList  = NullList;
  1423.     CustomRead(NewHeader,name,1);
  1424. }
  1425. int CustomExit()
  1426. {
  1427.     ListItem *i;
  1428.     int mods = 0;
  1429.     Widget w;
  1430.  
  1431.     for (i = CustomHeaders.First; i != 0; i = i->Next)
  1432.       {
  1433.         CustomHeader *Header = i->Pointer;
  1434.         mods += Header->Modified;
  1435.       }
  1436.  
  1437.     if (mods>0)
  1438.       {
  1439.         w = MidasFetch("MidasCustomExitDialog",0);
  1440.         XtManageChild(w);
  1441.         ExitResponse = -1;
  1442.         for (;ExitResponse == -1;) MidasFetchDispatchEvent();
  1443.       }
  1444.     if (ExitResponse == 2 )              /* Cancel */   
  1445.       {
  1446.         XtUnmanageChild(w);
  1447.         return 0;    
  1448.       }
  1449.     if (ExitResponse == 1 )              /* Yes    */
  1450.       for (i = CustomHeaders.First; i != 0; i = i->Next)
  1451.         {
  1452.           CustomHeader *Header = i->Pointer;
  1453.           if (Header->Modified != 0)
  1454.             CustomWrite(Header,i->Entry);
  1455.         }
  1456.     return 1;
  1457. }
  1458. static void CustomExitCallback(w,tag,cbDataP)
  1459.       Widget w; 
  1460.       int    *tag; 
  1461.       XmAnyCallbackStruct *cbDataP;
  1462. {
  1463.     ExitResponse = *tag;
  1464. }
  1465. void CustomInit()
  1466. {
  1467.     static MrmRegisterArg reglist[] = {
  1468.         {"CustomAddVerb",             (caddr_t)   CustomAddVerb},
  1469.         {"CustomDelVerb",             (caddr_t)   CustomDelVerb},
  1470.         {"CustomSelVerb",             (caddr_t)   CustomSelVerb},
  1471.         {"CustomSelConfVerb",         (caddr_t)   CustomSelConfVerb},
  1472.         {"CustomAddMenu",             (caddr_t)   CustomAddMenu},
  1473.         {"CustomDelMenu",             (caddr_t)   CustomDelMenu},
  1474.         {"CustomSelMenu",             (caddr_t)   CustomSelMenu},
  1475.         {"CustomSelConfMenu",         (caddr_t)   CustomSelConfMenu},
  1476.         {"CustomVMAddSeparator",      (caddr_t)   CustomVMAddSeparator},
  1477.         {"CustomVMAddVerb",           (caddr_t)   CustomVMAddVerb},
  1478.         {"CustomVMAddMenu",           (caddr_t)   CustomVMAddMenu},
  1479.         {"CustomVMDel",               (caddr_t)   CustomVMDel},
  1480.         {"CustomVMSel",               (caddr_t)   CustomVMSel},
  1481.         {"CustomVMSelConf",           (caddr_t)   CustomVMSelConf},
  1482.         {"CustomVMUp",                (caddr_t)   CustomVMUp},
  1483.         {"CustomVMDown",              (caddr_t)   CustomVMDown},
  1484.         {"CustomUpdateSensitivity",   (caddr_t)   CustomUpdateSensitivityCallback},
  1485.         {"CustomCreate",              (caddr_t)   CustomCreateCallback },
  1486.         {"CustomApply",               (caddr_t)   CustomApply },
  1487.         {"CustomReset",               (caddr_t)   CustomReset },
  1488.         {"CustomOk",                  (caddr_t)   CustomOk },
  1489.         {"CustomCancel",              (caddr_t)   CustomCancel },
  1490.         {"CustomExit",                (caddr_t)   CustomExitCallback }
  1491.     };
  1492.     MrmRegisterNames(reglist, XtNumber (reglist));
  1493.  
  1494.     CustomHeaders = NullList;
  1495.  
  1496.     MidasDeclareVerb("CUSTOM CREATE      upname Widget"     ,CustomCreate);
  1497.     MidasDeclareVerb("CUSTOM POPUP       upname"            ,CustomPopup);
  1498.     MidasDeclareVerb("CUSTOM CONNECT     upname name Widget",CustomConnect);
  1499.     MidasDeclareVerb("CUSTOM WRITE       upname {name}"     ,CustomWriteUser);
  1500.     MidasDeclareVerb("CUSTOM READ USER   upname {name}"     ,CustomReadUser);
  1501.     MidasDeclareVerb("CUSTOM READ SYSTEM upname {name}"     ,CustomReadSystem);
  1502. }
  1503.